import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        int i = 10;

// 装箱操作，新建一个 Integer 类型对象，将 i 的值放入对象的某个属性中
        Integer ii = Integer.valueOf(i);//是手动装箱

        Integer ij = new Integer(i);//是手动装箱




// 拆箱操作，将 Integer 对象中的值取出，放到一个基本数据类型中
        int j = ii.intValue();

        Integer a = new Integer(10);

//显示拆箱 拆箱为自己指定的元素
        int c = a.intValue();
        System.out.println(c);

        double d = a.doubleValue();
        System.out.println(d);


      /*  int i = 10;
        Integer ii = i; // 自动装箱
        Integer ij = (Integer)i; // 自动装箱

        int j = ii; // 自动拆箱
        int k = (int)ii; // 自动拆箱*/
    }
    public static void main1(String[] args) {
        Integer a = 127;
        Integer b = 127;
        Integer c = 128;
        Integer d = 128;
        System.out.println(a == b);
        System.out.println(c == d);
    }
}

/*class MyArray<T>(){
    public Object[] array = new Object[10];
//public T[] array = new T[10]; 不允许 实例化一个泛型数组
//public T[] array = (T[])new Object[10];//这样写也不好！！

    public T[] arrays = (T[])new Object[10];


    public static void main3(String[] args) {
        //泛型是如何编译的
        MyArray<String> myArray = new MyArray<>();*/


        //String[] ret = (String) myArray.getArray();
        //没意义，已经强制转换过了！本质它是一个 Object数组，
        //啥都能放，你怎么确定放的就是字符串？
        //String[] ret = myArray.getArray();也还是不行
        /*总的来说，就是我们返回的Object数组里面，可能存放的是任何的数据类型，
        可能是String，可能是Person，运行的时候，
        直接转给String类型的数组，编译器认为是不安全的。*/
        //Object[] ret = myArray.getArray();
        //System.out.println(Arrays.toString(ret));
    //}

/*
    public Object[] getArray() {
        return  arrays;
    }
*/


   /* public T[] getArray() {
        return array;
    }*/

    //那我就要有这个方法呢？
/*    public T[] getArray() {
        return  （T[]）arrays;
    }*/

//}
class GenericArray<T> {
    private T[] array;

    public GenericArray(int size) {
        // 使用反射创建泛型数组
        array = (T[]) new Object[size];
    }

    public T[] getArray() {
        return array;
    }

    public static void main(String[] args) {
        GenericArray<String> genericArray = new GenericArray<>(10);
        String[] array = genericArray.getArray();
        System.out.println(Arrays.toString(array));
    }
}
class ExampleClass<T extends Number> {
    private T value;

    public ExampleClass(T value) {
        this.value = value;
    }

    public T getValue() {
        return value;
    }

    // 其他方法和逻辑

}
class Test{
    public static void main(String[] args) {
        List<String> strings = Arrays.asList("Hello", "World");
        printList(strings); // 类型推导成功，类型参数为String
    }
    public static <T> void printList(List<T> list) {
        for (T item : list) {
            System.out.println(item);
        }
    }
}

class Test2{
    public static <T> T copy(T item) {
        return item;
    }

    public static void main(String[] args) {

        String str = "Hello";
        String copiedStr = copy(str); // 类型推导成功，类型参数为String
    }
}

class Tset3{
    public static <T> void process(T item) {
        // 泛型方法的实现
    }

    public static <T> void process(List<T> list) {
        // 另一个泛型方法的实现
    }

    public static void main(String[] args) {
        List<String> strings = Arrays.asList("Hello", "World");
        process(strings); // 编译器无法推导出类型参数，需要显式指定
    }
}
class Test4{
    public static <T, U> void process(T item, List<U> list) {


    }

    // 泛型方法的实现

    public static void main(String[] args) {

        String str = "Hello";
        List<Integer> numbers = Arrays.asList(1, 2, 3);
        process(str, numbers); // 编译器无法推导出类型参数，需要显式指定}
    }
}


 class GenericTypeExample {
        public static void main(String[] args) {
            List<String> list = new ArrayList<>(); // 使用泛型类型

            list.add("Hello");
            // list.add(123); // 编译错误，无法将整数添加到字符串列表中

            String str = list.get(0); // 不需要进行类型转换
            System.out.println(str);
        }
    }